Web application generator

ABSTRACT

A method, system and apparatus for providing a web application generator to generate the basis for a complete web application source code. Based on graphical user interface input files provided by graphic designers, the web application generator generates application framework code, an event handler skeleton and business logic foundation code. Web developers then prepare additional source code using an object-oriented programming language based on the event handler skeleton and business logic foundation code to create web application business logic objects and event handler methods. Ultimately the graphical user interface input files prepared by the graphic designers and web application source code prepared by the web developers are dynamically bound at runtime.

CROSS-REFERENCE TO RELATED APPLICATION

[0001] This application claims priority from provisional U.S. PatentApplication Ser. No. 60/190,364 entitled HTML TO WEB APPLICATIONGENERATOR filed on Mar. 17, 2000, the entirety of which is incorporatedby reference herein.

FIELD

[0002] A method, system and apparatus for generating web applicationsource code, and, more specifically, a method, system and apparatus thatreads a set of graphical web application screens as an input andgenerates the basis for a complete web application source code as theoutput.

BACKGROUND

[0003] The increasing popularity of the World Wide Web and otherInternet-based applications has encouraged many software companies andcorporations to allocate major resources towards web-enabling existingor new applications. For example, most retail applications conductedsolely by phone or face-to-face in the past are now also conductedelectronically over the World Wide Web.

[0004] Several approaches are used by web application developers todevelop web applications. Each web application generally consists of theapplication framework, the application graphical user interface (GUI),application event handler(s) and the application business logic. A firstapproach initiates with graphic designers and/or business analystsspecifying web application screens in Hypertext Markup Language (HTML)format using visual HTML editors such as Microsoft FrontPage, NetscapeComposer and Adobe GoLive. The resulting HTML files are then given toweb developers who specialize in computer programming. The webdevelopers choose a traditional programming language such as C, C⁺⁺, orPerl, prepare the programming source code files and embed the HTML tagsfrom the HTML files provided by the graphic designers/business analystsdirectly into the web application programming source code. The webdevelopers must also write the application framework and event handlercode. All application source code files are then compiled intoexecutable objects that are later installed within a web applicationserver for access by web browsers.

[0005] However, after the web developers embed the HTML tags into theapplication source code, it is difficult for the graphicdesigners/business analysts to visualize how the web application screensappear by analyzing the HTML tags intermixed with the programminglanguage code. As a result, modifying or changing the graphical userinterface is difficult after the initial development. Further, eachgraphical user interface modification requires the web developers tore-compile the application source code and reinstall the object codewithin the web application server. Finally, the web developers mustmanually write the application framework and event handler code, whichis a complex task and often introduces errors into the web application.

[0006] A second approach also initiates with graphic designers and/orbusiness analysts specifying web application screens in HTML formatusing a visual HTML editor. The resulting HTML files are then given toweb developers who specialize in computer programming. However, insteadof using a traditional programming language such as C, C⁺⁺ or Perl towrite the web application, the web developers write scripting languagecode such as JavaScript, VBScript, PHP Hypertext Preprocesor (PHP) orColdFusion directly into the HTML files. All application code files arelater interpreted at runtime based on a web request.

[0007] However, because of the scripting nature of the programminglanguage, it is difficult for web developers to write structural orobject-oriented code. Also, the final application source code includesmany different HTML files whose structure and naming system do notreflect the purpose of the code residing inside them. Further, it isdifficult for web developers to add functionality using this approach.Finally, since most scripting languages are interpreted at runtime basedon a web request, the runtime performance of the web application is muchslower than for a compiled web application.

[0008] A third approach, the Enhydra XMLC compiler introduced by LutrisTechnologies, initiates with graphic designers and/or business analystsspecifying web application screens in either HTML, Website MarkupLanguage (WML) or Extensible Markup Language (XML) format. The resultingfiles are then converted by the XMLC compiler into a Java classcontaining an industry standard Document Object Model (DOM) tree. ThisDOM tree is a collection of Java objects that allows web developers toremove, update or add new content to the DOM tree. Also, this conversionseparates the input files into an XML class that the graphicdesigners/business analysts can manipulate, separate from the webdevelopers preparing the application framework and business logic. Thus,graphic designers/business analysts can view and test the applicationscreens as a standalone component, while web developers prepare theapplication source code.

[0009] However, the Enhydra XMLC compiler does not generate applicationframework code or event handier code, nor does it generate any type ofskeleton for the application framework or event handler methods toassist the web developers. In fact, the DOM object tree requires furthermanipulation by the web developers, including setting all attributes, toconvert the DOM object tree into a “string” which is readable by a webbrowser within the Transmission Control Protocol/Internet Protocol(TCP/IP). Thus, the Enhydra XMLC Compiler approach relies on the webdevelopers to write the application framework code, event handler code,and develop the code for displaying outputs using the generated DOMobject tree. Further, after the initial files created by the graphicdesigners/business analysts are compiled by the XMLC compiler, anychanges to the web application screens by the graphic designers/businessanalysts must be manually re-compiled by the web developers before theweb application is available based on a web browser request.

SUMMARY

[0010] The above identified problems are solved and a technical advanceis achieved by the web application generator. In accordance with oneembodiment of the web application generator, there is provided a methodof generating computer code for a web application, and dynamicallybinding input files from graphic designers and source code from webdevelopers, comprising the web application server receiving input filesfrom graphic designers or business analysts, wherein the input files areat least one web application graphical user interface. The webapplication server determines if an application framework code isavailable for the web application, and retrieves the applicationframework code from an application directory. If the applicationframework code is not available for the web application, then the webapplication server generates the application framework code, along witha business logic foundation code, an event handler skeleton and agraphical user interface code. Further, based on work by web developers,the web application server receives web application business logicobjects and event handlers from the web developers, and organizes theapplication framework code, web application business logic objects andevent handler methods into web application source code. The methodfurther comprises compiling the web application source code. Modifiedinput files may then be received by the web application server from thegraphic designers or business analysts, and the modified input files arecompiled and dynamically bound with the compiled web application sourcecode at runtime. Generating the event handler skeleton comprises parsingthe input files, reviewing each parsed input file for a tag type,attribute name and attribute value, and determining an event handlermethod based on the tag type, attribute name and attribute value.

[0011] An advantage of the web application generator is that the graphicdesigners can modify the web application graphical user interface at thesame time that the web developers are preparing the web applicationbusiness logic objects and event handler methods. Also, modifications tothe input files that make up the graphical user interface areautomatically re-compiled or re-interpreted at runtime without affectingthe parallel work of the web developers. Further, the event handlerskeleton, business logic foundation code and graphical user interfacecode provide web developers with a framework for finalizing the webapplication source code.

[0012] It is not intended that the method, system and apparatus forproviding a web application generator be summarized here in itsentirety. Rather, further features, aspects and advantages of the webapplication generator are set forth in or are apparent from thefollowing drawings, detailed description and claims which follow.

BRIEF DESCRIPTION OF THE DRAWINGS

[0013] Further aspects of the method, system and apparatus for providinga web application generator will be more readily appreciated upon reviewof the detailed description set forth below when taken in conjunctionwith the accompanying drawings, of which:

[0014]FIG. 1 is a network schematic of an embodiment of the webapplication generator system by which web applications are accessed;

[0015]FIG. 2 is a network schematic of an embodiment of the webapplication generator system by which web applications are generated;

[0016]FIG. 3 is a block diagram of an embodiment of the web applicationserver 100;

[0017]FIG. 4 is a block diagram of an embodiment illustrating thecomponents of a web application 400;

[0018]FIG. 5 is a flow diagram 500 illustrating an embodiment of theprocess by which a web application is generated and sent to a webbrowser;

[0019]FIG. 6 is a flow diagram 600 illustrating an embodiment of theprocess by which input files are applied to the web applicationgenerator and web application source code is created;

[0020]FIG. 7 is a flow diagram 700 illustrating an embodiment of theprocess of applying input files to the web application generator;

[0021]FIG. 8 is an embodiment of web page 800 generated by HTML files:

[0022]FIG. 9 is an embodiment of web page 900 generated by HTML files;and

[0023]FIG. 10 is an embodiment of web page 1000 generated by HTML filesand web application source code.

[0024] It will be understood that the foregoing brief description andthe following detailed description are exemplary and explanatory of themethod, system and apparatus for providing a web application generator,but are not intended to be restrictive thereof or limiting of theadvantages which can be achieved by the web application generator. Thus,the accompanying drawings, referred to herein and constituting a parthereof, illustrate embodiments of the web application generator and,together with the detailed description, serve to explain the principlesof the web application generator.

DETAILED DESCRIPTION

[0025] The web application generator system is illustrated generally inFIG. 1. First, users may request and access web applications in avariety of ways. For example, a user may access the Internet with apersonal computer (PC) 105. The PC 105 usually contains web browsersoftware, such as Microsoft Internet Explorer or Netscape Navigator. Theuser provides a uniform resource locator (URL) address using the webbrowser, which accesses the Internet in hypertext transfer protocol(HTTP) format to contact the application server 100 identified by theURL address. Based on the particular URL address, the application server100 prepares the appropriate files and delivers them to the requestingweb browser by means of the Internet. A user may also access theInternet with a PC which is part of a local area network (LAN). Theuser's PC in a LAN, such as PC 120, accesses a web application in thesame manner as PC 105, except that the URL address request and responsemust additionally travel within the LAN 115 and through the LAN server110 prior to reaching the Internet. Finally, a user may access a webapplication with a wireless device, such as a personal digital assistant(PDA) 135 or a cellular phone. For example, the PDA 135 contains webbrowser software that accepts a URL address input from the user, andaccesses the Internet in a wireless fashion. Based on the URL address,the request is sent to the appropriate application server, where the webapplication requested is prepared and sent back to the requesting PDA.Thus, the web application may be requested in any technologicallyfeasible fashion, including in a wireless fashion.

[0026] The web application generator/web application server isillustrated generally in FIG. 2. The web application server 100comprises a web application generator 205. Web applications aregenerally prepared by graphic designers/business analysts 210 and webdevelopers 215. In one embodiment, the graphic designers/businessanalysts 210, on the one hand, create the web application screens(graphical user interface) in one of several available formats, such asXML and XSL (Extensible Style Language), HTML, cHTML (compact HypertextMarkup Language) and WML.

[0027] The choice of web application screen format depends on the typesof devices targeted by the graphic designers/business analysts 210 andweb developers 215 for accessing the web application being developed.For example, for web browser access only, the web application screenformat can be HTML. For wireless application protocol (WAP) phone accessonly, the web application screen format can be WML. For i-mode phoneaccess only, the web application screen format can be cHTML. Finally,for browser, WAP phone, i-mode phone and other device access, the webapplication screen format can be XML and XSL, particularly because XMLis a “meta” language which is used to create other languages such asHTML, WML and cHTML. (XSL defines the standard stylesheet language forXML).

[0028] The web developers 215 are typically computer programmers who usea programming language, such as the Java language developed by SunMicrosystems, to write the underlying function for the web application.

[0029] Exemplary components of the web application server 100 areillustrated in FIG. 3. The primary component of web application server100 is processor 305, which may be any commonly availablemicroprocessor. Processor 305 may be operatively connected to furtherexemplary components, such as RAM/ROM 310, clock 315, input/outputdevices 320 and memory 325 which, in turn, stores one or more computerprograms 330 and databases 335.

[0030] Processor 305 operates in conjunction with random-access memoryand read-only memory. The random-access memory (RAM) portion of RAM/ROM310 may be a suitable number of Single In-Line Memory Module (SIMM)chips having a storage capacity (typically measured in kilobytes ormegabytes) sufficient to store and transfer processing instructionsutilized by processor 305 which may be received by application programs330. The read-only memory (ROM) portion of RAM/ROM 310 may be anypermanent non-rewritable memory medium capable of storing andtransferring processing instructions performed by processor 305 during astart-up routine of web application server 100.

[0031] Clock 315 may be an on-board component of processor 305 whichdictates a clock speed (typically measured in MHz) at which processor305 performs and synchronizes communication between the internalcomponents of web application server 100.

[0032] Input/output devices 320 may be one or more known devices usedfor receiving operator inputs, network data, and the like andtransmitting outputs resulting therefrom. Accordingly, exemplary inputdevices may include a keyboard, a mouse, a voice recognition unit andthe like for receiving operator inputs. Output devices may include anyknown devices used to transmit data, including transmitting data overthe Internet. Other input/output devices may include a telephone ornetwork connection device, such as a telephone modem, a cable modem, aT-1 connection, a digital subscriber line or a network card, forcommunicating data to and from other computer devices over the Internet.

[0033] Memory 325 may be an internal or external large capacity devicefor storing computer processing instructions, computer-readable data,and the like. The storage capacity of memory 325 is typically measuredin megabytes or gigabytes. Accordingly, memory 325 may be one or more ofthe following: a floppy disk in conjunction with a floppy disk drive, ahard disk drive, a CD-ROM disk and reader/writer, a DVD disk andreader/writer, a ZIP disk and a ZIP drive, and/or any other computerreadable medium that may be encoded with processing instructions in aread-only or read-write format.

[0034] Memory 325 may store a plurality of programs 330. Programs 330may include web application generator 205. Memory 325 also includesdatabases 335 comprising multiple blocks of information relevant to theweb application.

[0035] A web application 400, illustrated generally in FIG. 4, comprisesapplication graphical user interfaces (GUI) 405 (prepared by the graphicdesigners/business analysts 210), application framework 410, applicationevent handler 415 and application business logic 420. Applicationframework 410 provides instruction to the operating system of the webapplication server 100, and determines/coordinates the execution of eachfunction performed by the web application. The application framework 410also acts as a conduit between the web browser request (in the form of aURL address) and the interaction of the graphics (prepared by thegraphic designers/business analysts 210) and function (written by theweb developers 215). The application event handler 415 is equivalent toa “click method” object in an object-oriented programming language forhandling requests based on the GUI <input> tags. The application eventhandler 415 coordinates between the application framework 410 and theapplication business logic 420. The application business logic 420controls the function portion of the web application. Also, theapplication business logic 420 is generally invoked by the applicationevent handler 415.

[0036] Web Application Development

[0037] The web application development and deployment involves a seriesof steps illustrated in FIGS. 5-7. As shown in FIG. 5, the first stepcomprises one or multiple graphic designers and/or business analysts 210creating web application screens using visual editors or a text editor(step 505). In one embodiment, the application screens are written inHTML format using a visual HTML editor, such as Microsoft FrontPage,Adobe GoLive or Netscape Composer.

[0038] Once the graphic designer(s) 210 are satisfied that theapplication screens contain all the necessary visual input and outputelements for the web application, all the application screens areapplied to the web application generator as input files (step 510). Inone embodiment, the input files are in HTML format.

[0039] In other embodiments, the web application screens may be in otherformats, such as XML, XSL, WML and cHTML, depending on the types ofdevices targeted for the web application. All such languages are createdusing XML, and as a result, their syntax is exactly the same. Forexample, a simple HTML file is as follows:

[0040] <html>

[0041] <body>

[0042] <p> Hello World. </p>

[0043] <body>

[0044] </html>

[0045] The same file in WML format is as follows:

[0046] <wml>

[0047] <card>

[0048] <p> Hello World. </p>

[0049] </card>

[0050] </wml>

[0051] Thus, both examples show essentially the same tags but indifferent languages.

[0052] As illustrated in FIG. 6, the web application generator 205 readsthe set of web application screens as the input 605 and generates webapplication source code 610 as the output. This web application sourcecode output 610 comprises web application framework code 615, eventhandler code 620, graphical user interface (GUI) code 625, businesslogic foundation code 630 and additional files 635. The web applicationgenerator 205 generates the same application framework code 615, eventhandler code 620, graphical user interface code 625, business logicfoundation code 630 and additional files 635 regardless of the languageformat for the input files, because the input tags are interpreted inthe same fashion for the different languages (e.g., XML, HTML, etc.).

[0053]FIG. 7 illustrates how the input files are applied to the webapplication generator. As shown in FIG. 7, web application generator 205first determines if application framework code 615 is already availableby searching for its existence in the application directory (step 705).Application framework code is specific for a particular web application.Once it is generated for the web application, it is stored in theapplication directory of the application web server 100. However, aseparate web application requires a separate application framework code.Further, the same application provided by graphic designers/businessanalysts in multiple input formats (e.g., HTML and WML) uses the sameapplication framework code and does not require multiple generations ofapplication framework code.

[0054] Web application generator 205 also determines if business logicfoundation code 630 was previously generated for the web application.Business logic foundation code is also specific for a particular webapplication. In one embodiment, business logic foundation code 630 isavailable if application framework code 615 is available. However, inanother embodiment, application framework code 615 may be availablewhile business logic foundation code 630 is not. In this case, businesslogic foundation code 630 may be generated by the web applicationgenerator 205.

[0055] If application framework code 615 is not found in the applicationdirectory, web application generator 205 generates application frameworkcode 615 and business logic foundation code 630 (step 710). Applicationframework code 615 is generated independent of the content of the inputfiles 605, and provides the framework for the entire web application.Business logic foundation code 630 is also generated independent of theinput files 605, whereas event handler code 620 and GUI code 625 dependon the content of the input files 605. If application framework code 615and business logic foundation code 630 were created earlier for this webapplication, step 710 is skipped.

[0056] Next, web application generator 205 reads each input file 605(step 715), and parses the input file to create an object representationof the file for subsequent manipulation (step 720). After parsing theinput file, web application generator 205 analyzes what is in the parsedfile and, in one embodiment, attempts to identify certain input tags(step 725). Such tags include, but are not limited to, the following:comment tag password tag JLMShowView tag include tag text area tagJLMShowParentView tag variable tag select tag repeat tag output tagcheckbox tag if else tag frame tag radio tag anchor tag hidden tag formtag JLMClick tag text tag JLVDefaultClick tag

[0057] After identifying the input tag, web application generator 205searches for specific attributes within the input tag, based on theinput tag type. In one embodiment, certain tags have a single attribute,while other tags have multiple attributes. After identifying eachattribute within the tag, web application generator 205 identifies anattribute value associated with the attribute name. Ultimately, based onthe input tag, attribute name(s) and associated attribute value(s), webapplication generator 205 relies on a particular “rule” (or fixedformula) within web application server memory 325 to generate eventhandler code 620 and GUI code 625 (step 730). Thus, the input tag,attribute name and attribute value determine the “rule” that webapplication generator 205 relies on to generate event handler code 620and GUI code 625.

[0058] For example, in one embodiment, one tag of an input file in HTMLformat is “<input type=submit name=JLMClick value=Add>”. Web applicationgenerator 205 first identifies the tag as an “input” tag, nextidentifies the attribute names as “name” and “value”, and furtheridentifies the associated attribute values as “JMLClick” and “Add”.Based on the input tag, attribute names and associated attribute values,web application generator 205 relies on a particular rule in webapplication server memory 325 to generate the following event handlermethod: “public void add (App app) throws Exception”, as well as a GUIcode in the form of a source file such as “indexClick.java.” If one ofthe attribute values was something other than JLMClick, then webapplication generator 205 would have relied on a separate rule in webapplication server memory 325 to generate event handler code 620 and GUIcode 625.

[0059] Alternatively, in another embodiment, one tag of an input file inWML format is:

[0060] <go href=“./?JLMClick=Add”/>

[0061] Web application generator 205 identifies the input tag (“go”),attribute name (“href”) and associated attribute value(““./?JLMClick=Add”/”). Since this tag is the same input tag as thefirst example except in a different format (WML vs. HTML), webapplication generator 205 relies on the same rule as the first exampleto generate the same event handler method and GUI code.

[0062] In one embodiment, web application source code output 610 isgenerated as a corresponding Java class. However, in other embodiments,web application source code output 610 may be structured for anyobject-oriented programming language, such as JavaScript, C^(#), C⁺⁺ orSmallTalk.

[0063] As illustrated in FIG. 6, web application source code output 610comprises web application framework code 615, event handler code 620,graphical user interface (GUI) code 625, business logic foundation code630 and additional files 635. In one embodiment, each portion of webapplication source code output 610 is generated in Java as follows basedon HTML input files. In other embodiments, different input formatlanguages and different programming languages may be used.

[0064] First, web application framework code 615 comprises anapplication object and a complete Java servlet web application frameworkobject. In other embodiments, the servlet can be based on differentobject-oriented programming languages.

[0065] The application object is passed to all event handlers (clickmethods). Also, the application object allows the event handlers (clickmethods) to access: (1) the HTTP request object received from the webbrowser (in the form of a URL address), (2) the HTTP response objectsent back to the requesting web browser, (3) application business logic,(4) the application database connection, and (5) application structuredquery language (SQL) statements and application properties. Further, theapplication object allows event handlers (click methods) to set thedynamic values for <input> and <output> tags within an HTML screen, andallows event handlers (click methods) to show an HTML screen. Finally,the application object is immediately ready for use within the webapplication and requires no additions or revisions by web developers.

[0066] The Java servlet web application framework object receivesrequests from web browsers, dispatches those requests with theapplication object to appropriate event handlers (click methods),receives responses back from event handlers (click methods) via theapplication object and transmit responses back to requesting webbrowsers. The Java servlet web application framework object also readsthe application properties file and makes all application propertiesavailable in the application object, and reads the application SQL fileand makes all application SQL statements available in the applicationobject. Further, the Java servlet web application framework objectmanages database connections for the application by establishing,sharing and terminating database connections, regardless of databasetypes and application specific contents. Database connections arenetwork connections from the web application server to the databasespecified by the web developers, such as an Oracle 8i database,Microsoft SQL server, etc. Finally, the Java servlet web applicationframework object is immediately ready for use within the web applicationand requires no additions or revisions by web developers.

[0067] Event handler code 620 comprises a skeleton or framework made upof an event handler (click method) object that accepts requests fromHTML <input> tags with JLMClick name and submit type attributes in theHTML files. As discussed above in connection with FIG. 7, for eachJLMClick submit <input> tag identified by web application generator 205,a corresponding event handler (click method) is generated to handle therequest. Upon receipt of event handler code 620 as an output from webapplication generator 205, web developers 215 simply need to writeappropriate source code into the event handler code skeleton to drivethe application business logic in response to user interactions.

[0068] Graphical user interface code 625 is a programming proxy to inputfiles 605. Input files 605 contain output parameters that must be set upby web developers 215 as a result of the function, and web developers215 need a way to set those parameters in an object-oriented programmingenvironment. Graphical user interface code 625 provides this in the formof a programming proxy or view. Later, during the deployment phase,application framework code 615 binds the output parameters to theinterpreted or compiled input files, developer by graphicdesigners/business analysts 210.

[0069] Next, business logic foundation code 630 is the foundation forthe application business logic object that is fully prepared by webdevelopers 215 and accessible to all event handlers (click methods) bymeans of the application object. Upon receipt of business logicfoundation code 630 as an output from web application generator 205, webdevelopers 215 assemble reusable object-oriented business components andwrite all the core business logic that drives the web application, andparticularly its function.

[0070] Web developers 215 may ignore business logic foundation code 630,and prepare the application business logic objects from “scratch.”However, business logic foundation code 630 is provided to assist webdevelopers 215 with a foundation or skeleton, but may be completelyignored by web developers 215. In fact, in another embodiment, nobusiness logic foundation code is generated whatsoever as part of theoutput from the web application generator.

[0071] Finally, additional files 635 are generated by web applicationgenerator 205, allowing information to be initially set by webdevelopers 215, but changeable by application administrators withoutrequiring a recompilation of the application source code. For example,in one embodiment, an application runtime properties file is generatedwhere web developers set all the application runtime properties whichare made available to event handlers (click methods) by the applicationservlet framework. This application runtime properties file may bechanged by application administrators during deployment by simplyediting the file rather than editing the application source code andre-compiling the application source code. Also, an application SQLstatements file may also be generated where web developers set all theapplication SQL statements which are made available to event handlers(click methods) by the application servlet framework. This applicationSQL statements file may be changed by application administrators duringdeployment on different databases by simply editing the file rather thanediting the application source code and re-compiling the applicationsource code.

[0072] Returning to FIG. 5, web developers 215 prepare web applicationsource code in an object-oriented programming language based on eventhander code 620, graphical user interface code 625 and business logicfoundation code 630 (step 520). As described in detail above inconnection with FIG. 6, the web developers 215: (1) write appropriatesource code into event handler code 620 to drive the applicationbusiness logic in response to user interactions, (2) refer to graphicaluser interface code 625 as a programming proxy, and (3) optionally relyon business logic foundation code 630 to assemble reusableobject-oriented business components and write all the core businesslogic that drives the web application.

[0073] As web developers 215 are busy adding functionality to eventhandler code 620 and business logic foundation code 630, graphicdesigners/business analysts 210 determine if the web application screensrequire further edits (step 515). If the graphic designers/businessanalysts 210 elect to edit the web application screens, they can work inparallel (with the web developers 215) on the application screens toalter and/or improve the design of the graphical user interface (step525). Such design changes takes place immediately without requiring webapplication generator 205 to re-generate web application source code 610or web developers 215 to modify and re-compile existing source code.However, at runtime, application framework code 615 detects any changeto the web application screens, since such screens were initially inputs605 to web application generator 205, and if changes are detected, theinput files are either re-compiled or re-interpreted automatically. Inone embodiment, the graphic design is greatly simplified because theHTML files contain pure HTML tags without any confusing script. Thus,the HTML files can be easily manipulated by graphic designers/businessanalysts 210 using any visual HTML editor. Also, no HTML tag is embeddedin the programming source code and therefore, the user interface is 100%customizable just by editing the HTML files without having to edit thesource code.

[0074] Also, web developers 215 benefit from the separation of the HTMLtags from the programming code because the web developers 215 can useany object-oriented programming language such as Java to develop the webapplication rather than using a scripting language that requiresline-by-line interpretation. An object-oriented programming languageallows the web application to achieve better scalability in terms ofproviding additional features and complexity in the complete life cycleof the web application. Also, the use of a compiled programming language(as opposed to an interpreted programming language) allows a betterruntime performance for the web application than a web applicationdeveloped with an interpreted scripting language.

[0075] When web developers 215 are finished preparing web applicationsource code 610, web application source code 610 is either compiled orinterpreted by the programming language compiler/interpreter in whichthe code is written (step 530). In one embodiment, the web applicationsource code is written in the Java programming language and compiled bya Java compiler. In other embodiments, the web application source codemay be written and compiled or interpreted in JavaScript, C#, C⁺⁺,SmallTalk or other programming languages.

[0076] At some point, graphic designers 210 complete any design changesto the graphical user interface and web application source code 610prepared by web developers 215 is either compiled or interpreted. Thus,the development phase is complete and the web application is ready fordeployment.

[0077] Web Application Deployment

[0078] Based on a request for the web application from a web browser,the web application server 100 dynamically binds graphical userinterface (GUI) files with web application business logic objects atruntime in order to provide the web application to the web browser (step535). As described above, if the web application screens were modifiedafter initially being applied to web application generator 205, they areautomatically re-compiled or re-interpreted by application frameworkcode 615. In one embodiment, HTML, WML or cHTML input files can eitherbe interpreted or compiled by the application framework at runtime.Compilation of the input files (instead of interpreting them) increasesapplication framework performance as well as complexity. Further, theinput files may be compiled at runtime into Java Document Object Model(DOM) objects and the resulting objects are stored in a cache in thecomputer memory for performance purposes. In another embodiment, XMLand/or XSL files can also either be interpreted or compiled by theapplication framework at runtime. For example, at runtime, theapplication framework compiles the XML files into DOM objects,transforms the DOM objects into the appropriate DOM objects based on theXSL files, caches the transformed objects and binds the data from thebusiness logic components to produce the final screen viewed by theapplication users.

[0079] Cost Calculator Example

[0080] In an exemplary embodiment, a cost calculator web application isdeveloped as follows. First, a graphic designer/business analyst createsa cost calculator screen using a visual HTML editor or a text editor toproduce the following HTML tags within an HTML file:

[0081] 1. <!-- File: CostCalculator.html -->

[0082] 2. <html>

[0083] 3. <head><title>Cost Calculator</title></head>

[0084] 4. <body>

[0085] 5. <h3>Cost Calculator</h3>

[0086] 6. <form method=post action=./>

[0087] 7. Item Code: <input type=text name=item_code><br>

[0088] 8. Item Quantity: <input type=text name=item_qty><br>

[0089] 9. Unit Price: <output name=unit price></output><br>

[0090] 10. Total: <output name=total_cost></output><br>

[0091] 11. <input type=submit name=JLMClick value=Calculate>

[0092] 12. </form>

[0093] 13. </body>

[0094] 14. </html>

[0095] Line 1 is an HTML comment showing the name of the HTML file.Lines 2-14 contain the HTML tags for the HTML document. Line 3 containsthe “head” part of the HTML document, that sets the title of thedocument to “Cost Calculator.” This title appears in the title bar ofmost web browsers receiving this web application. Lines 4-13 contain the“body” part of the HTML document. Line 5 shows a “Cost Calculator”heading at the top of the document. Lines 6-12 contain the “form” partof the HTML document, allowing users to send information to the webapplication. For example, line 7 produces a text box for a user to entera product item code. Line 8 produces another text box for a user toenter the product item quantity. Lines 9 and 10 show the unit price andtotal cost for the product item. The <output> tag in lines 9-10 isprocessed by the web application server on the server-side while all theother HTML tags are processed by the web browser on the user-side.Finally, line 11 shows a “calculate” button for the user to click inorder to send the item code and quantity to the web application serverfor Computation of the total cost. The initial cost calculator screen800 is illustrated in FIG. 8.

[0096] After the graphic designer/business analyst is satisfied that theHTML screen contains all the necessary input and output elements for thecost calculator web application, the HTML files are sent through the webapplication generator in order to create the web application sourcecode. The web application source code created comprises Java files thatmake up the application framework code, event handler code, graphicaluser interface code, business logic foundation code and additionalapplication files. For example, the application framework code comprisesan application object (App.java) and a complete Java servlet webapplication framework object (AppServlet.java). Both the applicationobject and the complete Java servlet web application framework objectare described in detail above in connection with FIG. 6, and are readyfor use within the web application and require no additions or revisionsby web developers. The event handler code and graphical user interfacecode, also described in detail in connection with FIG. 6, comprise oneobject file (CostCalculator.java). This object file requires webdevelopers to write additional source code to drive the applicationbusiness logic in response to user interactions. Next, the businesslogic foundation code, described in detail in connection with FIG. 6,comprises a foundation file (AppModel.java) for the application businesslogic object that is accessible to all event handlers (click methods) bymeans of the application object file. Web developers may ignore thisfile, or use it to assemble reusable object-oriented business componentsand write all the core business logic that drives the web application.Finally, two additional files (App.properties, App.sql) are created thatallow the web developers to set the application runtime properties andapplication SQL statements for the web application. After thedevelopment phase, application administrators may change either theapplication runtime properties or the application SQL statements bysimply editing either file rather than editing the application sourcecode and re-compiling the application source code.

[0097] A portion of the web application source code created by the webapplication generator for the cost calculator is shown as follows: //File: AppModel.java // original file generated by WebAppGen public classAppModel { // application business logic variables and methods herepublic void showHome(App app) throws Exception { // application homepage code here app.showView(“CostCalculator.html”); }AppModel(AppServlet as) throws Exception { // application initializationhere } } // File: CostCalculator.java // original file generated byWebAppGen public class CostCalculator { public static void calculate(Appapp) throws Exception { // click method code hereapp.showView(“CostCalculator.html”); } } // File: AppModel.java // addedgetUnitPrice business logic method public class AppModel { //application business logic variables and methods here public intgetUnitPrice(String item_code) { // this is an example business logicmethod if (item_code.equals(“20000412”)) return 20; else return 50; }public void showHome(App app) throws Exception { // application homepage code here app.showView(“CostCalculator.html”); }AppModel(AppServlet as) throws Exception { // application initializationhere } }

[0098] For example, Line 11 of the CostCalculator.html file (“<inputtype=submit name=JLMCLick value=Calculate>”) is an HTML tag that causesthe web application generator to generate a corresponding “voidcalculate (App app)” event handler method based on the tag type,attribute name and attribute value. When a user clicks on the“Calculate” button within a web browser, the request to the webapplication is dispatched to the corresponding “calculate” method by theweb application framework.

[0099] Next, the web developers add functionality to the AppModel.javaand CostCalculator.java files created by the web application generator.Also, the web , developers can set parameters, as shown below in the webapplication source code, to set the unit price and total cost values inthe application object: // File: CostCalculator.java // added code toget the unit price // and compute the total cost // in the calculateclick method public class CostCalculator { public static voidcalculate(App app) throws Exception { // click method code here Stringitem_code = app.getParameter(“item_code”); int unit_price =app.model.getUnitPrice(item_code); int item_qty =Integer.parseInt(app.getParameter (“item_qty”)); int total_cost =unit_price * item_qty; app.setParameter(“unit_price”,String.valueOf(unit_price)); app.setParameter(“total_cost”,String.valueOf(total_cost)); app.showView(“CostCalculator.html”); } }

[0100] Later at runtime, the application uses these values to replacethe <output name=unit_price></output> and <outputname=total_cost></output> HTML tags in the CostCalculator.html filebefore sending as a response to the web browser.

[0101] The graphic designers may work in parallel while the webdevelopers add functionality to the CostCalculator.html file to improvethe design of the graphical user interface. For example, the graphicdesigners can modify the original CostCalculator.html file as follows:

[0102] 1. <!-- File: CostCalculator.html -->

[0103] 2. <!-- modified to make the user interface look better -->

[0104] 3. <html>

[0105] 4. <head><title>Cost Calculator</title></head>

[0106] 5. <body>

[0107] 6. <center>

[0108] 7. <h3>Cost Calculator</h3>

[0109] 8. <form method=post action=/>

[0110] 9. <table>

[0111] 10. <tr><td>Item Code:</td>

[0112] 11. <td><input type=text name=item_code></td></tr>

[0113] 12. <tr><td>Item Quantity:</td>

[0114] 13. <td><input type=text name=item_qty></td></tr>

[0115] 14. <tr><td>Unit Price</td>

[0116] 15. <td><output name=unit price></output></td></tr>

[0117] 16. <tr><td>Total</td>

[0118] 17. <td><output name=total_cost></output></td></tr>

[0119] 18. </table>

[0120] 19. <input type=submit name=JLMClick value=Calculate>

[0121] 20. </form>

[0122] 21. </center>

[0123] 22. </body>

[0124] 23. </html>

[0125] Lines 6 and 21 were added to center the user interface within thebrowser. Lines 9 and 18 were added to arrange the item code, itemquantity, unit price and total names and values in table format.Further, in lines 10-17, the <tr> and </tr> tags specify a row of thetable while the <td> and </td> tags specify a cell of the table. Themodified cost calculator screen 900 is illustrated in FIG. 9.

[0126] After the modifications are added to the CostCalculator.htmlfile, the effect takes place immediately without requiring the webapplication generator to re-generate the web application source code orthe web developers to modify and recompile the existing source code. Atruntime, the Cost Calculator.html files will be re-compiledautomatically by the application framework.

[0127] Upon completion by the graphic designers of the HTML files andcompilation of the web application source code prepared by the webdevelopers, the web application is available for use.

[0128] As shown in FIG. 10, the user inputs an item code and itemquantity through a web browser. The web application takes those inputsand provides a unit price and total as outputs.

[0129] Although illustrative embodiments have been described herein indetail, it should be noted and understood that the descriptions havebeen provided for purposes of illustration only and that othervariations both in form and detail can be made thereupon withoutdeparting from the spirit and scope of the method, system and apparatusfor providing a web application generator. The terms and expressionshave been used as terms of description and not terms of limitation.There is no limitation to use the terms or expressions to exclude anyequivalents of features shown and described or portions thereof, and theweb application generator should be defined with the claims that follow.

1. A method of generating computer code for a web application,comprising: receiving input files from a graphic designer, wherein theinput files are at least one web application graphical user interface;determining if an application framework code is available for the webapplication; generating the application framework code, a business logicfoundation code, an event handler skeleton and a graphical userinterface code; receiving web application business logic objects from aweb developer; receiving event handler methods from the web developer;organizing the application framework code, the web application businesslogic objects and the event handler methods into web application sourcecode; compiling the web application source code; receiving modifiedinput files from the graphic designer; compiling the modified inputfiles at runtime; and binding the compiled modified input files with thecompiled web application source code at runtime.
 2. A method ofgenerating computer code for a web application, comprising: receivinginput files, wherein the input files are at least one web applicationgraphical user interface; generating an application framework code andan event handler skeleton; receiving web application business logicobjects; receiving event handler methods; organizing the applicationframework code, the web application business logic objects and the eventhandler methods into application source code; and binding the webapplication source code with the input files at runtime.
 3. The methodof claim 2 , wherein generating an event handler skeleton furthercomprises: parsing at least one input file; reviewing the parsed inputfile for a tag type, an attribute name and an attribute value; anddetermining an event handler method based on the tag type, the attributename and the attribute value.
 4. The method of claim 2 , wherein the webapplication source code is generated in an object-oriented programminglanguage.
 5. The method of claim 4 , wherein the object-orientedprogramming language is Java.
 6. The method of claim 4 , wherein theobject-oriented programming language is C⁺⁺.
 7. The method of claim 2 ,further comprising determining if the application framework code isavailable for the web application.
 8. The method of claim 2 , furthercomprising generating a business logic foundation code.
 9. The method ofclaim 2 , further comprising generating a graphical user interface code.10. The method of claim 9 , wherein generating a graphical userinterface code is based on the input files.
 11. The method of claim 2 ,wherein generating an event handler skeleton is based on the inputfiles.
 12. The method of claim 2 , further comprising compiling the webapplication source code.
 13. The method of claim 2 , further comprisinginterpreting the web application source code.
 14. The method of claim 2, wherein the input files are in XML format.
 15. The method of claim 2 ,wherein the input files are in HTML format.
 16. The method of claim 2 ,wherein the input files are in cHTML format.
 17. The method of claim 2 ,wherein the input files are in WML format.
 18. The method of claim 2 ,further comprising receiving modified input files.
 19. The method ofclaim 18 , further comprising compiling the modified input files atruntime.
 20. The method of claim 19 , further comprising binding the webapplication source code with the compiled modified input files atruntime.
 21. The method of claim 20 , wherein the modified input filesare compiled into DOM objects at runtime.
 22. The method of claim 18 ,further comprising interpreting the modified input files at runtime. 23.The method of claim 22 , further comprising binding the web applicationsource code with the interpreted modified input files at runtime. 24.The method of claim 2 , further comprising generating applicationruntime properties.
 25. The method of claim 2 , further comprisinggenerating application SQL statements.
 26. The method of claim 2 ,wherein the application framework code comprises an application objectand a servlet web application framework object.
 27. A method ofgenerating computer code for a web application, comprising: receivinginput files, wherein the input files are at least one web applicationgraphical user interface; retrieving an application framework code froman application directory; generating an event handler skeleton;receiving web application business logic objects; receiving eventhandler methods; organizing the application framework code, the webapplication business logic objects and the event handler methods intoapplication source code; and binding the web application source codewith the input files at runtime.
 28. The method of claim 27 , furthercomprising retrieving a business logic foundation code.
 29. The methodof claim 27 , further comprising generating a business logic foundationcode.
 30. The method of claim 27 , wherein generating an event handlerskeleton further comprises: parsing at least one input file; reviewingthe parsed input file for a tag type, an attribute name and an attributevalue; and determining an event handler method based on the tag type,the attribute name and the attribute value.
 31. The method of claim 27 ,wherein the web application source code is generated in anobject-oriented programming language.
 32. The method of claim 27 ,further comprising determining if the application framework code isavailable for the web application.
 33. The method of claim 27 , furthercomprising generating a graphical user interface code.
 34. The method ofclaim 33 , wherein generating a graphical user interface code is basedon the input files.
 35. The method of claim 27 , wherein generating anevent handler skeleton is based on the input files.
 36. The method ofclaim 27 , further comprising compiling the web application source code.37. The method of claim 27 , further comprising interpreting the webapplication source code.
 38. The method of claim 27 , wherein the inputfiles are in XML format.
 39. The method of claim 27 , wherein the inputfiles are in HTML format.
 40. The method of claim 27 , wherein the inputfiles are in cHTML format.
 41. The method of claim 27 , wherein theinput files are in WML format.
 42. The method of claim 27 , furthercomprising receiving modified input files.
 43. The method of claim 42 ,further comprising compiling the modified input files at runtime. 44.The method of claim 43 , further comprising binding the web applicationsource code with the compiled modified input files at runtime.
 45. Themethod of claim 42 , further comprising interpreting the modified inputfiles at runtime.
 46. The method of claim 45 , further comprisingbinding the web application source code with the interpreted modifiedinput files at runtime.
 47. The method of claim 27 , wherein theapplication framework code comprises an application object and a servletweb application framework object.
 48. A method of generating computercode for a web application, comprising: receiving input files, whereinthe input files are at least one web application graphical userinterface; generating an application framework code and an event handlerskeleton; receiving web application business logic objects; receivingevent handler methods; organizing the application framework code, theweb application business logic objects and the event handler methodsinto web application source code; receiving modified input files; andbinding the modified input files with the web application source code atruntime.
 49. The method of claim 48 , further comprising compiling themodified input files at runtime.
 50. The method of claim 48 , furthercomprising interpreting the modified input files at runtime.
 51. Themethod of claim 48 , wherein generating an event handler skeletonfurther comprises: parsing at least one input file; reviewing the parsedinput file for a tag type, an attribute name and an attribute value; anddetermining an event handler method based on the tag type, the attributename and the attribute value.
 52. The method of claim 48 , wherein theweb application source code is generated in an object-orientedprogramming language.
 53. The method of claim 48 , further comprisingdetermining if the application framework code is available for the webapplication.
 54. The method of claim 48 , further comprising generatinga business logic foundation code.
 55. The method of claim 48 , furthercomprising generating a graphical user interface code.
 56. The method ofclaim 48 , further comprising compiling the web application source code.57. The method of claim 48 , further comprising interpreting the webapplication source code.
 58. The method of claim 48 , wherein the inputfiles are in XML format.
 59. The method of claim 48 , wherein the inputfiles are in HTML format.
 60. The method of claim 48 , wherein the inputfiles are in cHTML format.
 61. The method of claim 48 , wherein theinput files are in WML format.
 62. The method of claim 49 , wherein themodified input files are compiled into DOM objects at runtime.
 63. Themethod of claim 48 , wherein the application framework code comprises anapplication object and a servlet web application framework object.
 64. Amethod of generating computer code for a web application, comprising:receiving input files, wherein the input files are at least one webapplication graphical user interface; retrieving an applicationframework code from an application directory; generating an eventhandler skeleton; receiving web application business logic objects;receiving event handler methods; organizing the application frameworkcode, the web application business logic objects and the event handlermethods into web application source code; receiving modified inputfiles; and binding the modified input files with the web applicationsource code at runtime.
 65. The method of claim 64 , wherein generatingan event handler skeleton further comprises: parsing at least one inputfile; reviewing the parsed input file for a tag type, an attribute nameand an attribute value; and determining an event handler method based onthe tag type, the attribute name and the attribute value.
 66. The methodof claim 64 , further comprising determining if the applicationframework code is available for the web application.
 67. The method ofclaim 64 , further comprising generating a business logic foundationcode.
 68. The method of claim 64 , further comprising retrieving abusiness logic foundation code.
 69. The method of claim 64 , furthercomprising generating a graphical user interface code.
 70. The method ofclaim 64 , wherein genera ting an event handler skeleton is based on theinput files.
 71. The method of claim 64 , wherein the input files are inXML format.
 72. The method of claim 64 , wherein the input files are inHTML format.
 73. The method of claim 64 , wherein the input files are incHTML format.
 74. The method of claim 64 , wherein the input files arein WML format.
 75. The method of claim 64 , further comprising compilingthe modified input files at runtime.
 76. The method of claim 64 ,further comprising interpreting the modified input files at runtime. 77.The method of claim 64 , wherein the application framework codecomprises an application object and a servlet web application frameworkobject.
 78. A method of generating computer code for a web application,comprising: receiving a business logic foundation code, an event handlerskeleton and a graphical user interface code; preparing web applicationbusiness logic objects based on the business logic foundation code; andpreparing event handler methods based on the event handler skeleton. 79.A system for generating computer code for a web application, comprising:means for receiving input files from a graphic designer, wherein theinput files are at least one web application graphical user interface;means for determining if an application framework code is available forthe web application; means for generating the application frameworkcode, a business logic foundation code, an event handler skeleton and agraphical user interface code; means for receiving web applicationbusiness logic objects from a web developer; means for receiving eventhandler methods from the web developer; means for organizing theapplication framework code, the web application business logic objectsand the event handler methods into web application source code; meansfor compiling the web application source code; means for receivingmodified input files from the graphic designer; means for compiling themodified input files at runtime; and means for binding the compiledmodified input files with the compiled web application source code atruntime.
 80. A system for generating computer code for a webapplication, comprising: means for receiving input files, wherein theinput files are at least one web application graphical user interface;means for generating an application framework code and an event handlerskeleton; means for receiving web application business logic objects;means for receiving event handler methods; means for organizing theapplication framework code, the web application business logic objectsand the event handler methods into application source code; and meansfor binding the web application source code with the input files atruntime.
 81. The system of claim 80 , wherein means for generating anevent handler skeleton further comprises: means for parsing at least oneinput file; means for reviewing the parsed input file for a tag type, anattribute name and an attribute value; and means for determining anevent handler method based on the tag type, the attribute name and theattribute value.
 82. The system of claim 80 , wherein the webapplication source code is generated in an object-oriented programminglanguage.
 83. The system of claim 82 , wherein the object-orientedprogramming language is Java.
 84. The system of claim 82 , wherein theobject-oriented programming language is C⁺⁺.
 85. The system of claim 80, further comprising means for determining if the application frameworkcode is available for the web application.
 86. The system of claim 80 ,further comprising means for generating a business logic foundationcode.
 87. The system of claim 80 , further comprising means forgenerating a graphical user interface code.
 88. The system of claim 87 ,wherein means for generating a graphical user interface code is based onthe input files.
 89. The system of claim 80 , wherein means forgenerating an event handler skeleton is based on the input files. 90.The system of claim 80 , further comprising means for compiling the webapplication source code.
 91. The system of claim 80 , further comprisingmeans for interpreting the web application source code.
 92. The systemof claim 80 , wherein the input files are in XML format.
 93. The systemof claim 80 , wherein the input files are in HTML format.
 94. The systemof claim 80 , wherein the input files are in cHTML format.
 95. Thesystem of claim 80 , wherein the input files are in WML format.
 96. Thesystem of claim 80 , further comprising means for receiving modifiedinput files.
 97. The system of claim 96 , further comprising means forcompiling the modified input files at runtime.
 98. The system of claim97 , further comprising means for binding the web application sourcecode with the compiled modified input files at runtime.
 99. The systemof claim 98 , wherein the modified input files are compiled into DOMobjects at runtime.
 100. The system of claim 96 , further comprisingmeans for interpreting the modified input files at runtime.
 101. Thesystem of claim 100 , further comprising means for binding the webapplication source code with the interpreted modified input files atruntime.
 102. The system of claim 80 , further comprising means forgenerating application runtime properties.
 103. The system of claim 80 ,further comprising means for generating application SQL statements. 104.The system of claim 80 , wherein the application framework codecomprises an application object and a servlet web application frameworkobject.
 105. A system for generating computer code for a webapplication, comprising: means for receiving input files, wherein theinput files are at least one web application graphical user interface;means for retrieving an application framework code from an applicationdirectory; means for generating an event handler skeleton; means forreceiving web application business logic objects; means for receivingevent handler methods; means for organizing the application frameworkcode, the web application business logic objects and the event handlermethods into application source code; and means for binding the webapplication source code with the input files at runtime.
 106. The systemof claim 105 , further comprising means for retrieving a business logicfoundation code.
 107. The system of claim 105 , further comprising meansfor generating a business logic foundation code.
 108. The system ofclaim 105 , wherein means for generating an event handler skeletonfurther comprises: means for parsing at least one input file; means forreviewing the parsed input file for a tag type, an attribute name and anattribute value; and means for determining an event handler method basedon the tag type, the attribute name and the attribute value.
 109. Thesystem of claim 105 , wherein the web application source code isgenerated in an object-oriented programming language.
 110. The system ofclaim 105 , further comprising means for determining if the applicationframework code is available for the web application.
 111. The system ofclaim 105 , further comprising means for generating a graphical userinterface code.
 112. The system of claim 111 , wherein means forgenerating a graphical user interface code is based on the input files.113. The system of claim 105 , wherein means for generating an eventhandler skeleton is based on the input files.
 114. The system of claim105 , further comprising means for compiling the web application sourcecode.
 115. The system of claim 105 , further comprising means forinterpreting the web application source code.
 116. The system of claim105 , wherein the input files are in XML format.
 117. The system ofclaim 105 , wherein the input files are in HTML format.
 118. The systemof claim 105 , wherein the input files are in cHTML format.
 119. Thesystem of claim 105 , wherein the input files are in WML format. 120.The system of claim 105 , further comprising means for receivingmodified input files.
 121. The system of claim 120 , further comprisingmeans for compiling the modified input files at runtime.
 122. The systemof claim 121 , further comprising means for binding the web applicationsource code with the compiled modified input files at runtime.
 123. Thesystem of claim 120 , further comprising means for interpreting themodified input files at runtime.
 124. The system of claim 123 , furthercomprising means for binding the web application source code with theinterpreted modified input files at runtime.
 125. The system of claim105 , wherein the application framework code comprises an applicationobject and a servlet web application framework object.
 126. A system forgenerating computer code for a web application, comprising: means forreceiving input files, wherein the input files are at least one webapplication graphical user interface; means for generating anapplication framework code and an event handler skeleton; means forreceiving web application business logic objects; means for receivingevent handler methods; means for organizing the application frameworkcode, the web application business logic objects and the event handlermethods into web application source code; means for receiving modifiedinput files; and means for binding the modified input files with the webapplication source code at runtime.
 127. The system of claim 126 ,further comprising means for compiling the modified input files atruntime.
 128. The system of claim 126 , further comprising means forinterpreting the modified input files at runtime.
 129. The system ofclaim 126 , wherein means for generating an event handler skeletonfurther comprises: means for parsing at least one input file; means forreviewing the parsed input file for a tag type, an attribute name and anattribute value; and means for determining an event handler method basedon the tag type, the attribute name and the attribute value.
 130. Thesystem of claim 126 , wherein the web application source code isgenerated in an object-oriented programming language.
 131. The system ofclaim 126 , further comprising means for determining if the applicationframework code is available for the web application.
 132. The system ofclaim 126 , further comprising means for generating a business logicfoundation code.
 133. The system of claim 126 , further comprising meansfor generating a graphical user interface code.
 134. The system of claim126 , further comprising means for compiling the web application sourcecode.
 135. The system of claim 126 , further comprising means forinterpreting the web application source code.
 136. The system of claim126 , wherein the input files are in XML format.
 137. The system ofclaim 126 , wherein the input files are in HTML format.
 138. The systemof claim 126 , wherein the input files are in cHTML format.
 139. Thesystem of claim 126 , wherein the input files are in WML format. 140.The system of claim 127 , wherein the modified input files are compiledinto DOM objects at runtime.
 141. The system of claim 126 , wherein theapplication framework code comprises an application object and a servletweb application framework object.
 142. A system for generating computercode for a web application, comprising: means for receiving input files,wherein the input files are at least one web application graphical userinterface; means for retrieving an application framework code from anapplication directory; means for generating an event handler skeleton;means for receiving web application business logic objects; means forreceiving event handler methods; means for organizing the applicationframework code, the web application business logic objects and the eventhandler methods into web application source code; means for receivingmodified input files; and means for binding the modified input fileswith the web application source code at runtime.
 143. The system ofclaim 142 , wherein means for generating an event handler skeletonfurther comprises: means for parsing at least one input file; means forreviewing the parsed input file for a tag type, an attribute name and anattribute value; and means for determining an event handler method basedon the tag type, the attribute name and the attribute value.
 144. Thesystem of claim 142 , further comprising means for determining if theapplication framework code is available for the web application. 145.The system of claim 142 , further comprising means for generating abusiness logic foundation code.
 146. The system of claim 142 , furthercomprising means for retrieving a business logic foundation code. 147.The system of claim 142 , further comprising means for generating agraphical user interface code.
 148. The system of claim 142 , whereinmeans for generating an event handler skeleton is based on the inputfiles.
 149. The system of claim 142 , wherein the input files are in XMLformat.
 150. The system of claim 142 , wherein the input files are inHTML format.
 151. The system of claim 142 , wherein the input files arein cHTML format.
 152. The system of claim 142 , wherein the input filesare in WML format.
 153. The system of claim 142 , further comprisingmeans for compiling the modified input files at runtime.
 154. The systemof claim 142 , further comprising means for interpreting the modifiedinput files at runtime.
 155. The system of claim 142 , wherein theapplication framework code comprises an application object and a servletweb application framework object.
 156. A system for generating computercode for a web application, comprising: means for receiving a businesslogic foundation code, an event handler skeleton and a graphical userinterface code; means for preparing web application business logicobjects based on the business logic foundation code; and means forpreparing event handler methods based on the event handler skeleton.157. An article of manufacture for causing a computer to generatecomputer code for a web application, comprising: means for causing thecomputer to receive input files from a graphic designer, wherein theinput files are at least one web application graphical user interface;means for causing the computer to determine if an application frameworkcode is available for the web application; means for causing thecomputer to generate the application framework code, a business logicfoundation code, an event handler skeleton and a graphical userinterface code; means for causing the computer to receive webapplication business logic objects from a web developer; means forcausing the computer to receive event handler methods from the webdeveloper; means for causing the computer to organize the applicationframework code, the web application business logic objects and the eventhandler methods into web application source code; means for causing thecomputer to compile the web application source code; means for causingthe computer to receive modified input files from the graphic designer;means for causing the computer to compile the modified input files atruntime; and means for causing the computer to binding the compiledmodified input files with the compiled web application source code atruntime.
 158. An article of manufacture for causing a computer togenerate computer code for a web application, comprising: means forcausing the computer to receive input files, wherein the input files areat least one web application graphical user interface; means for causingthe computer to generate an application framework code and an eventhandler skeleton; means for causing the computer to receive webapplication business logic objects; means for causing the computer toreceive event handler methods; means for causing the computer toorganize the application framework code, the web application businesslogic objects and the event handler methods into application sourcecode; and means for causing the computer to bind the web applicationsource code with the input files at runtime.
 159. An article ofmanufacture for causing a computer to generate computer code for a webapplication, comprising: means for causing the computer to receive inputfiles, wherein the input files are at least one web applicationgraphical user interface; means for causing the computer to retrieve anapplication framework code from an application directory; means forcausing the computer to generate an event handler skeleton; means forcausing the computer to receive web application business logic objects;means for causing the computer to receive event handler methods; meansfor causing the computer to organize the application framework code, theweb application business logic objects and the event handler methodsinto application source code; and means for causing the computer to bindthe web application source code with the input files at runtime.
 160. Anarticle of manufacture for causing a computer to generate computer codefor a web application, comprising: means for causing the computer toreceive input files, wherein the input files are at least one webapplication graphical user interface; means for causing the computer togenerate an application framework code and an event handler skeleton;means for causing the computer to receive web application business logicobjects; means for causing the computer to receive event handlermethods; means for causing the computer to organize the applicationframework code, the web application business logic objects and the eventhandler methods into web application source code; means for causing thecomputer to receive modified input files; and means for causing thecomputer to bind the modified input files with the web applicationsource code at runtime.
 161. An article of manufacture for causing acomputer to generate computer code for a web application, comprising:means for causing the computer to receive input files, wherein the inputfiles are at least one web application graphical user interface; meansfor causing the computer to retrieve an application framework code froman application directory; means for causing the computer to generate anevent handler skeleton; means for causing the computer to receive webapplication business logic objects; means for causing the computer toreceive event handler methods; means for causing the computer toorganize the application framework code, the web application businesslogic objects and the event handler methods into web application sourcecode; means for causing the computer to receive modified input files;and means for causing the computer to bind the modified input files withthe web application source code at runtime.
 162. A server for generatingcomputer code for a web application, comprising: a storage device; and aprocessor connected to the storage device, the storage device storing aprogram for controlling the processor; the processor operative with theprogram to: receive input files from a graphic designer, wherein theinput files are at least one web application graphical user interface;determine if an application framework code is available for the webapplication; generate the application framework code, a business logicfoundation code, an event handler skeleton and a graphical userinterface code; receive web application business logic objects from aweb developer; receive event handler methods from the web developer;organize the application framework code, the web application businesslogic objects and the event handler methods into web application sourcecode; compile the web application source code; receive modified inputfiles from the graphic designer; compile the modified input files atruntime; and bind the compiled modified input files with the compiledweb application source code at runtime.
 163. A server for generatingcomputer code for a web application, comprising: a storage device; and aprocessor connected to the storage device, the storage device storing aprogram for controlling the processor; the processor operative with theprogram to: receive input files, wherein the input files are at leastone web application graphical user interface; generate an applicationframework code and an event handler skeleton; receive web applicationbusiness logic objects; receive event handler methods; organize theapplication framework code, the web application business logic objectsand the event handler methods into application source code; and bind theweb application source code with the input files at runtime.
 164. Aserver for generating computer code for a web application, comprising: astorage device; and a processor connected to the storage device, thestorage device storing a program for controlling the processor; theprocessor operative with the program to: receive input files, whereinthe input files are at least one web application graphical userinterface; retrieve an application framework code from an applicationdirectory; generate an event handler skeleton; receive web applicationbusiness logic objects; receive event handler methods; organize theapplication framework code, the web application business logic objectsand the event handler methods into application source code; and bind theweb application source code with the input files at runtime.
 165. Aserver for generating computer code for a web application, comprising: astorage device; and a processor connected to the storage device, thestorage device storing a program for controlling the processor; theprocessor operative with the program to: receive input files, whereinthe input files are at least one web application graphical userinterface; generate an application framework code and an event handlerskeleton; receive web application business logic objects; receive eventhandler methods; organize the application framework code, the webapplication business logic objects and the event handler methods intoweb application source code; receive modified input files; and bind themodified input files with the web application source code at runtime.166. A server for generating computer code for a web application,comprising: a storage device; and a processor connected to the storagedevice, the storage device storing a program for controlling theprocessor; the processor operative with the program to: receive inputfiles, wherein the input files are at least one web applicationgraphical user interface; retrieve an application framework code from anapplication directory; generate an event handler skeleton; receive webapplication business logic objects; receive event handler methods;organize the application framework code, the web application businesslogic objects and the event handler methods into web application sourcecode; receive modified input files; and bind the modified input fileswith the web application source code at runtime.